{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 04. Dueling Network\n",
    "\n",
    "[Z. Wang et al., \"Dueling Network Architectures for Deep Reinforcement Learning.\" arXiv preprint arXiv:1511.06581, 2015.](https://arxiv.org/pdf/1511.06581.pdf)\n",
    "\n",
    "The proposed network architecture, which is named *dueling architecture*, explicitly separates the representation of state values and (state-dependent) action advantages. \n",
    "\n",
    "![fig1](https://user-images.githubusercontent.com/14961526/60322956-c2f0b600-99bb-11e9-9ed4-443bd14bc3b0.png)\n",
    "\n",
    "The dueling network automatically produces separate estimates of the state value function and advantage function, without any extra supervision. Intuitively, the dueling architecture can learn which states are (or are not) valuable, without having to learn the effect of each action for each state. This is particularly useful in states where its actions do not affect the environment in any relevant way. \n",
    "\n",
    "The dueling architecture represents both the value $V(s)$ and advantage $A(s, a)$ functions with a single deep model whose output combines the two to produce a state-action value $Q(s, a)$. Unlike in advantage updating, the representation and algorithm are decoupled by construction.\n",
    "\n",
    "$$A^\\pi (s, a) = Q^\\pi (s, a) - V^\\pi (s).$$\n",
    "\n",
    "The value function $V$ measures the how good it is to be in a particular state $s$. The $Q$ function, however, measures the the value of choosing a particular action when in this state. Now, using the definition of advantage, we might be tempted to construct the aggregating module as follows:\n",
    "\n",
    "$$Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + A(s, a; \\theta, \\alpha),$$\n",
    "\n",
    "where $\\theta$ denotes the parameters of the convolutional layers, while $\\alpha$ and $\\beta$ are the parameters of the two streams of fully-connected layers.\n",
    "\n",
    "Unfortunately, the above equation is unidentifiable in the sense that given $Q$ we cannot recover $V$ and $A$ uniquely; for example, there are uncountable pairs of $V$ and $A$ that make $Q$ values to zero. To address this issue of identifiability, we can force the advantage function estimator to have zero advantage at the chosen action. That is, we let the last module of the network implement the forward mapping.\n",
    "\n",
    "$$\n",
    "Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + \\big( A(s, a; \\theta, \\alpha) - \\max_{a' \\in |\\mathcal{A}|} A(s, a'; \\theta, \\alpha) \\big).\n",
    "$$\n",
    "\n",
    "This formula guarantees that we can recover the unique $V$ and $A$, but the optimization is not so stable because the advantages have to compensate any change to the optimal action’s advantage. Due to the reason, an alternative module that replaces the max operator with an average is proposed:\n",
    "\n",
    "$$\n",
    "Q(s, a; \\theta, \\alpha, \\beta) = V (s; \\theta, \\beta) + \\big( A(s, a; \\theta, \\alpha) - \\frac{1}{|\\mathcal{A}|} \\sum_{a'} A(s, a'; \\theta, \\alpha) \\big).\n",
    "$$\n",
    "\n",
    "Unlike the max advantage form, in this formula, the advantages only need to change as fast as the mean, so it increases the stability of optimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.nn.utils import clip_grad_norm_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dueling Network\n",
    "\n",
    "Carefully take a look at advantage and value layers separated from feature layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        # set common feature layer\n",
    "        self.feature_layer = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        # set advantage layer\n",
    "        self.advantage_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, out_dim),\n",
    "        )\n",
    "\n",
    "        # set value layer\n",
    "        self.value_layer = nn.Sequential(\n",
    "            nn.Linear(128, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 1),\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        feature = self.feature_layer(x)\n",
    "        \n",
    "        value = self.value_layer(feature)\n",
    "        advantage = self.advantage_layer(feature)\n",
    "\n",
    "        q = value + advantage - advantage.mean(dim=-1, keepdim=True)\n",
    "        \n",
    "        return q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN + DuelingNet Agent (w/o Double-DQN & PER)\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "\n",
    "Aside from the dueling network architecture, the authors suggest to use Double-DQN and Prioritized Experience Replay as extra components for better performance. However, we don't implement them to simplify the tutorial. Here, DQNAgent is totally same as the one from *01.dqn.ipynb*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        # we clip the gradients to have their norm less than or equal to 10.\n",
    "        clip_grad_norm_(self.dqn.parameters(), 10.0)\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            self.env.render()\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "agent.env = gym.wrappers.Monitor(env, \"videos\", force=True)\n",
    "agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "videos/openaigym.video.11.12002.video000000.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "latest_file = max(list_of_files, key=os.path.getctime)\n",
    "print(latest_file)\n",
    "ipython_show_video(latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
